import * as vscode from 'vscode';
import {dedent} from "../../../utils";

// documentation中使用了代码块，代码块中写的事makedown格式，首行不能为空
let actionItems = [
    {
        "label": "triggerchat",
        "insertText": `
        function triggerchat(self, sMsg, chat, msgType)
            -- Your code here
        end
        `,
        "documentation": `
        ### 聊天触发前置接口

        \`triggerchat\`

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |sMsg     |\`string\`        |否   |    |说话内容 |
        |chat     |\`integer\`       |否   |    |聊天频道<br>1:系统<br>2:喊话<br>3:私聊<br>4:行会<br>5:组队<br>6:附近<br>7:世界<br>8:国家<br>9:联盟<br>40:行会通知|
        |msgType      |\`string\`        |否   |    |消息类型<br>1:普通消息<br>2:坐标<br>3:装备<br>5:系统通知消息,需使用特定富文本解析<br>6:系统通知消息,需使用FColor特定富文本解析<br>7:系统通知消息,需使用SRText特定富文本解析<br>8:猜拳 |
        |result |\`bool\`        |否   |   |    是否终止说话   |

        \`\`\`lua
        function triggerchat(self, sMsg, chat, msgType)
            if tonumber(sMsg) ~= nil then
                say(self, "不允许说数字。".."频道："..chat,"类型:"..msgType)
                return false
            end
            return true
        end
        \`\`\`
        `
    },
    {
        "label": "privatechat",
        "insertText": `
        function privatechat(self, sMsg, chat)
            -- Your code here
        end
        `,
        "documentation": `
        ### 收到私聊信息触发

        \`privatechat\`

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |sMsg     |\`string\`        |否   |    |说话内容 |
        |chat     |\`integer\`       |否   |    |聊天频道|
        |result |\`bool\`        |否   |   |    是否接收私信   |
        `
    },
    {
        "label": "takeonbeforeex",
        "insertText": `
        function takeonbeforeex(self, item, where, makeIndex)
            -- Your code here
        end
        `,
        "documentation": `
        ### 角色穿戴装备前触发

        \`takeonbeforeex\`

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |item     |\`object\`        |否   |    |   物品对象    |
        |where     |\`integer\`        |否   |  引擎64_23.10.24新增  |   装备位置    |
        |makeIndex     |\`integer\`        |否   |  引擎64_23.10.24新增  |   装备唯一ID    |
        |result |\`bool\`        |否   |   |   true = 允许操作<br>false = 阻止操作   |
        `
    },
    {
        "label": "takeoffbeforeex",
        "insertText": `
        function takeoffbeforeex(self, item, where, makeIndex)
            -- Your code here
        end
        `,
        "documentation": `
        ### 角色脱下装备前触发

        \`takeoffbeforeex\`

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |item     |\`object\`        |否   |    |   物品对象    |
        |where     |\`integer\`        |否   |  引擎64_23.10.24新增  |   装备位置    |
        |makeIndex     |\`integer\`        |否   |  引擎64_23.10.24新增  |   装备唯一ID    |
        |result |\`bool\`        |否   |   |   true = 允许操作<br>false = 阻止操作   |
        `
    },
    {
        "label": "takeonbefore",
        "insertText": `
        function takeonbefore(self, item)
            -- Your code here
        end
        `,
        "documentation": `
        ### 角色穿戴装备前触发

        \`takeonbefore(X)\`

        > X=装备位置

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |item     |\`object\`        |否   |    |   物品对象    |
        |result |\`bool\`        |否   |   |   true = 允许操作<br>false = 阻止操作   |
        `
    },
    {
        "label": "takeoffbefore",
        "insertText": `
        function takeoffbefore(self, item)
            -- Your code here
        end
        `,
        "documentation": `
        ### 角色脱下装备前触发

        \`takeoffbefore(X)\`

        > X=装备位置

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |item     |\`object\`        |否   |    |   物品对象    |
        |result |\`bool\`        |否   |   |   true = 允许操作<br>false = 阻止操作   |
        `
    },
    {
        "label": "takeonex",
        "insertText": `
        function takeonex(self, item, where, itemName, makeindex)
            -- Your code here
        end
        `,
        "documentation": `
        ### 角色穿戴装备后触发

        \`takeonex\`

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |item     |\`object\`        |否   |    |   物品对象    |
        |where    | \`integer\`       |否   |    |   穿/脱位置    |
        |itemName     |\`string\`        |否   |    |  物品名    |
        |makeindex    | \`integer\`       |否   |    |   唯一ID    |
        `
    },
    {
        "label": "takeoffex",
        "insertText": `
        function takeoffex(self, item, where, itemName, makeindex)
            -- Your code here
        end
        `,
        "documentation": `
        ### 角色脱下装备后触发

        \`takeoffex\`

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |item     |\`object\`        |否   |    |   物品对象    |
        |where    | \`integer\`       |否   |    |   穿/脱位置    |
        |itemName     |\`string\`        |否   |    |  物品名    |
        |makeindex    | \`integer\`       |否   |    |   唯一ID    |
        `
    },
    {
        "label": "takeon",
        "insertText": `
        function takeon(self, item)
            -- Your code here
        end
        `,
        "documentation": `
        ### 角色穿戴装备后触发

        \`takeon(X)\`

        > X=装备位置

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |item     |\`object\`        |否   |    |   物品对象    |
        `
    },
    {
        "label": "takeoff",
        "insertText": `
        function takeoff(self, item)
            -- Your code here
        end
        `,
        "documentation": `
        ### 角色脱下装备后触发

        \`takeoff(X)\`

        > X=装备位置

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |item     |\`object\`        |否   |    |   物品对象    |
        `
    },
    {
        "label": "herotakeonex",
        "insertText": `
        function herotakeonex(play, item, where, itemName, makeindex, hero)
            -- Your code here
        end
        `,
        "documentation": `
        ### 英雄穿戴装备后触发

        \`herotakeonex\`

        | 参数      | 类型      | 空   | 默认                | 注释      |
        | :-------- | :-------- | :--- | :------------------ | :-------- |
        | play      |\`object\`  | 否   |                     | 玩家对象  |
        | item      |\`object\`  | 否   |                     | 物品对象  |
        | where     |\`integer\` | 否   |                     | 穿/脱位置 |
        | itemName  |\`string\`  | 否   |                     | 物品名    |
        | makeindex |\`integer\` | 否   |                     | 唯一ID    |
        | hero      |\`object\`  | 否   | 引擎64_23.08.30新增 | 英雄对象  |
        `
    },
    {
        "label": "herotakeoffex",
        "insertText": `
        function herotakeoffex(play, item, where, itemName, makeindex, hero)
            -- Your code here
        end
        `,
        "documentation": `
        ### 英雄脱下装备后触发

        \`herotakeoffex\`

        | 参数      | 类型      | 空   | 默认                | 注释      |
        | :-------- | :-------- | :--- | :------------------ | :-------- |
        | play      |\`object\`  | 否   |                     | 玩家对象  |
        | item      |\`object\`  | 否   |                     | 物品对象  |
        | where     |\`integer\` | 否   |                     | 穿/脱位置 |
        | itemName  |\`string\`  | 否   |                     | 物品名    |
        | makeindex |\`integer\` | 否   |                     | 唯一ID    |
        | hero      |\`object\`  | 否   | 引擎64_23.08.30新增 | 英雄对象  |
        `
    },
    {
        "label": "checkdropuseitems",
        "insertText": `
        function checkdropuseitems(actor, where, itemIdx)
            -- Your code here
        end
        `,
        "documentation": `
        ### 人物死亡装备掉落前触发

        \`checkdropuseitems\`

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |actor    |\`object\`        |否   |    |   玩家对象    |
        |where    |\`integer\`       |否   |    |   装备位    |
        |itemIdx      |\`integer\`       |否   |    |   装备idx |
        | result   | \`bool\`    |否   |    | true = 允许掉落<br>false = 阻止掉落 |
        `
    },
    {
        "label": "dropuseitems",
        "insertText": `
        function dropuseitems(actor, item)
            -- Your code here
        end
        `,
        "documentation": `
        ### 参照装备投保已投保装备掉落触发

        \`dropuseitems(X)\`

        > X=装备位置

        | 参数  | 类型     | 空   | 默认                | 注释     |
        | :---- | :------- | :--- | :------------------ | :------- |
        | actor |\`object\` | 否   |                     | 玩家对象 |
        | item  |\`object\` | 否   | 引擎64_23.10.24新增 | 装备对象 |
        `
    },
    {
        "label": "itemexpired",
        "insertText": `
        function itemexpired(actor, item, name)
            -- Your code here
        end
        `,
        "documentation": `
        ### 角色装备过期触发

        \`itemexpired\`

        | 参数  | 类型     | 空   | 默认                | 注释     |
        | :---- | :------- | :--- | :------------------ | :------- |
        | actor |\`object\` | 否   |                     | 玩家对象 |
        | item  |\`object\` | 否   | 引擎64_23.08.30新增 | 物品对象 |
        | name  |\`string\` | 否   | 引擎64_23.08.30新增 | 物品名字 |
        `
    },
    {
        "label": "heroitemexpired",
        "insertText": `
        function heroitemexpired(actor, item, name, hero)
            -- Your code here
        end
        `,
        "documentation": `
        ### 英雄装备过期触发

        \`heroitemexpired\`

        | 参数  | 类型     | 空   | 默认                | 注释     |
        | :---- | :------- | :--- | :------------------ | :------- |
        | actor |\`object\` | 否   |                     | 玩家对象 |
        | item  |\`object\` | 否   | 引擎64_23.08.30新增 | 物品对象 |
        | name  |\`string\` | 否   | 引擎64_23.08.30新增 | 物品名字 |
        | hero  |\`object\` | 否   | 引擎64_23.08.30新增 | 英雄对象 |
        `
    },
    {
        "label": "takeoffexchange",
        "insertText": `
        function takeoffexchange(play, item, where, makeindex)
            -- Your code here
        end
        `,
        "documentation": `
        ### 角色脱下装备进入背包前触发

        \`takeoffexchange\`

        | 参数      | 类型     | 空   | 默认                | 注释       |
        | :-------- | :------- | :--- | :------------------ | :--------- |
        | play      |\`object\` | 否   |                     | 玩家对象   |
        | item      |\`object\` | 否   | 引擎64_23.08.30新增 | 装备对象   |
        | where     |\`string\` | 否   | 引擎64_23.08.30新增 | 装备位置   |
        | makeindex |\`bool\`   | 否   | 引擎64_23.08.30新增 | 装备唯一id |
        `
    },
    {
        "label": "herotakeoffexchange",
        "insertText": `
        function herotakeoffexchange(play, item, where, makeindex, hero)
            -- Your code here
        end
        `,
        "documentation": `
        ### 英雄脱下装备进入背包前触发

        \`herotakeoffexchange\`

        | 参数      | 类型     | 空   | 默认                | 注释       |
        | :-------- | :------- | :--- | :------------------ | :--------- |
        | play      |\`object\` | 否   |                     | 玩家对象   |
        | item      |\`object\` | 否   | 引擎64_23.08.30新增 | 装备对象   |
        | where     |\`string\` | 否   | 引擎64_23.08.30新增 | 装备位置   |
        | makeindex |\`bool\`   | 否   | 引擎64_23.08.30新增 | 装备唯一id |
        | hero      |\`object\` | 否   | 引擎64_23.08.30新增 | 英雄对象   |
        `
    },
    {
        "label": "itemdamage",
        "insertText": `
        function itemdamage(actor, item)
            -- Your code here
        end
        `,
        "documentation": `
        ### 装备持久消失触发

        \`itemdamage(X)\`

        > X=装备位置

        | 参数  | 类型     | 空   | 默认                | 注释     |
        | :---- | :------- | :--- | :------------------ | :------- |
        | actor |\`object\` | 否   |                     | 玩家对象 |
        | item  |\`object\` | 否   | 引擎64_23.10.24新增 | 装备对象 |
        `
    },
    {
        "label": "makeweaponunluck",
        "insertText": `
        function makeweaponunluck(actor, item)
            -- Your code here
        end
        `,
        "documentation": `
        ### 武器加诅咒前触发

        \`makeweaponunluck\`

        | 参数   | 类型     | 空   | 默认 | 注释                            |
        | :----- | :------- | :--- | :--- | :------------------------------ |
        | actor  |\`object\` | 否   |      | 玩家对象                        |
        | item   |\`object\` | 否   |      | 装备对象                        |
        | result |\`bool\`   | 否   |      | true = 诅咒<br>false = 阻止诅咒 |
        `
    },
    {
        "label": "bagusestoneitemok",
        "insertText": `
        function bagusestoneitemok(actor, item)
            -- Your code here
        end
        `,
        "documentation": `
        ### 镶嵌宝石触发

        \`bagusestoneitemok\`

        | 参数  | 类型     | 空   | 默认                | 注释     |
        | :---- | :------- | :--- | :------------------ | :------- |
        | actor |\`object\` | 否   |                     | 玩家对象 |
        | item  |\`object\` | 否   | 引擎64_23.10.24新增 | 装备对象 |
        `
    },
    {
        "label": "removestoneitem",
        "insertText": `
        function removestoneitem(actor, item)
            -- Your code here
        end
        `,
        "documentation": `
        ### 卸下宝石触发

        \`removestoneitem\`

        | 参数  | 类型     | 空   | 默认                | 注释     |
        | :---- | :------- | :--- | :------------------ | :------- |
        | actor |\`object\` | 否   |                     | 玩家对象 |
        | item  |\`object\` | 否   | 引擎64_23.10.24新增 | 装备对象 |
        `
    },
    {
        "label": "stdmodefunc",
        "insertText": `
        function stdmodefunc(self, item)
            -- Your code here
        end
        `,
        "documentation": `
        ### 双击类道具触发

        \`stdmodefunc(X)\`

        > X=道具表第5列(Anicount),支持道具表stdmode[2、31、200]类

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |item     |\`object\`        |否   |    |   物品对象    |
        |result       |\`bool\`       |否   |    |   是否允许使用 |
        \`\`\`lua
        function stdmodefunc100(actor, itemobj)
            if getbaseinfo(actor,6) < 50 then
                say(actor,"50级后才可使用")
                return false
            end
        end
        \`\`\`
        `
    },
    {
        "label": "beforeeatitem",
        "insertText": `
        function beforeeatitem(actor, itemobj, itemidx, itemMakeIndex, itemNum, stdMode)
            -- Your code here
        end
        `,
        "documentation": `
        ### 双击使用道具前触发

        \`beforeeatitem\`

        > 注:引擎24.0118 补全参数2 - 物品对象

        | 参数          | 类型      | 空   | 默认 | 注释                                |
        | :------------ | :-------- | :--- | :--- | :---------------------------------- |
        | actor         |\`string\`  | 否   |      | 玩家对象                            |
        | itemobj       |\`string\`  | 否   |      | 道具对象                            |
        | itemidx       |\`integer\` | 否   |      | 道具idx                             |
        | itemMakeIndex |\`integer\` | 否   |      | 道具唯一id                          |
        | itemNum       |\`integer\` | 否   |      | 道具数量                            |
        | stdMode       |\`integer\` | 否   |      | 物品表stdMode参数                   |
        | result        |\`boolean\` | 否   |      | 返回值<br>true=允许<br>false=不允许 |
        `
    },
    {
        "label": "moneychange",
        "insertText": `
        function moneychange(actor)
            -- Your code here
        end
        `,
        "documentation": `
        ### 货币改变触发

        \`moneychange(X)\`

        > X=货币道具表idx

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |actor     |\`object\`        |否   |    |   玩家对象    |

        \`\`\`lua
        for moneyIdx = 1, 100 do
            _G["moneychange"..moneyIdx] = function (actor)
                local formernum = getconst(actor, "<$OLDMONEY>")
                local curnum = querymoney(actor, moneyIdx)
                local name = getstditeminfo(moneyIdx, 1)
                release_print("货币【"..name.."】改变：", moneyIdx, curnum, formernum)
            end
        end
        \`\`\`
        `
    },
    {
        "label": "addbagbefore",
        "insertText": `
        function addbagbefore(self, item, itemidx, itemMakeIndex)
            -- Your code here
        end
        `,
        "documentation": `
        ### 物品进包前触发

        \`addbagbefore\`

        > 无返回值,不能阻止进包操作

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |item     |\`object\`        |否   |    |   物品对象    |
        |itemidx     |\`integer\`        |否   |    |   道具idx    |
        |itemMakeIndex     |\`integer\`        |否   |    |   道具唯一idx    |
        `
    },
    {
        "label": "addbag",
        "insertText": `
        function addbag(self, item)
            -- Your code here
        end
        `,
        "documentation": `
        ### 添加背包触发

        \`addbag\`

        > 接口为异步，物品进入背包时可能与原有物品堆叠起来了

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |item     |\`object\`        |否   |    |   物品对象    |
        `
    },
    {
        "label": "dropitemfrontex",
        "insertText": `
        function dropitemfrontex(play, dropItem, itemName, model)
            -- Your code here
        end
        `,
        "documentation": `
        ### 角色扔掉任意物品前触发

        \`dropitemfrontex\`

        | 参数     | 类型      | 空   | 默认                | 注释                                            |
        | :------- | :-------- | :--- | :------------------ | :---------------------------------------------- |
        | play     |\`object\`  | 否   |                     | 玩家对象                                        |
        | dropItem |\`object\`  | 否   | 引擎64_23.08.30新增 | 掉落物品                                        |
        | itemName |\`string\`  | 否   | 引擎64_23.08.30新增 | 物品名称                                        |
        | model    |\`integer\` | 否   | 引擎64_23.08.30新增 | 行为id<br>0=扔掉触发<br>1=人物掉落触发          |
        | result   |\`bool\`    | 否   |                     | 是否允许丢弃<br>true允许丢弃<br>false不允许丢弃 |
        `
    },
    {
        "label": "dropitemex",
        "insertText": `
        function dropitemex(play, dropItem, itemName)
            -- Your code here
        end
        `,
        "documentation": `
        ### 扔掉任意物品后触发

        \`dropitemex\`

        | 参数     | 类型     | 空   | 默认                | 注释     |
        | :------- | :------- | :--- | :------------------ | :------- |
        | play     |\`object\` | 否   |                     | 玩家对象 |
        | dropItem |\`object\` | 否   | 引擎64_23.08.30新增 | 掉落物品 |
        | itemName |\`string\` | 否   | 引擎64_23.08.30新增 | 物品名称 |
        `
    },
    {
        "label": "addherobag",
        "insertText": `
        function addherobag(self, item, hero)
            -- Your code here
        end
        `,
        "documentation": `
        ### 添加英雄背包触发

        \`addherobag\`

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |item     |\`object\`        |否   |    |   物品对象    |
        |hero     |\`object\`        |否   |    |   英雄对象    |
        `
    },
    {
        "label": "herodropitemfrontex",
        "insertText": `
        function herodropitemfrontex(actor, item)
            -- Your code here
        end
        `,
        "documentation": `
        ### 英雄扔掉物品前触发

        \`herodropitemfrontex\`

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |actor    |\`object\`        |否   |    |   玩家对象    |
        |item     |\`object\`        |否   |    |   物品对象    |
        `
    },
    {
        "label": "herodropitemex",
        "insertText": `
        function herodropitemex(actor, item)
            -- Your code here
        end
        `,
        "documentation": `
        ### 英雄扔掉物品后触发

        \`herodropitemex\`

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |actor    |\`object\`        |否   |    |   玩家对象    |
        |item     |\`object\`        |否   |    |   物品对象    |
        `
    },
    {
        "label": "herodropitemfront",
        "insertText": `
        function herodropitemfront(actor, item, hero)
            -- Your code here
        end
        `,
        "documentation": `
        ### 英雄扔掉物品前触发

        \`herodropitemfront(X)\`

        > X=物品Idx

        | 参数  | 类型     | 空   | 默认                | 注释     |
        | :---- | :------- | :--- | :------------------ | :------- |
        | actor |\`object\` | 否   |                     | 玩家对象 |
        | item  |\`object\` | 否   |                     | 物品对象 |
        | hero  |\`object\` | 否   | 引擎64_23.08.30新增 | 英雄对象 |
        `
    },
    {
        "label": "herodropitem",
        "insertText": `
        function herodropitem(actor, item, hero)
            -- Your code here
        end
        `,
        "documentation": `
        ### 英雄扔掉物品后触发

        \`herodropitem(X)\`

        > X=物品Idx

        | 参数  | 类型     | 空   | 默认                | 注释     |
        | :---- | :------- | :--- | :------------------ | :------- |
        | actor |\`object\` | 否   |                     | 玩家对象 |
        | item  |\`object\` | 否   |                     | 物品对象 |
        | hero  |\`object\` | 否   | 引擎64_23.08.30新增 | 英雄对象 |
        `
    },
    {
        "label": "crittrigger",
        "insertText": `
        function crittrigger(self, attack, damage, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 暴击触发

        \`crittrigger\` 支持物理攻击、魔法攻击 暴击触发

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |attack   |\`object\`        |否   |    |   受击对象    |
        |damage       |\`integer\`       |否   |    |   暴击后伤害值 |
        |MagicId      |\`integer\`       |否   |    |   技能ID |
        |result       |\`integer\`       |否   |    |   返回值，修改后的伤害 |
        `
    },
    {
        "label": "reboundhurt",
        "insertText": `
        function reboundhurt(actor, Hiter, Damage, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 伤害反弹触发

        \`reboundhurt\`

        | 参数    | 类型     | 空   | 默认 | 注释             |
        | :------ | :------- | :--- | :--- | :--------------- |
        | actor   |\`object\` | 否   |      | 玩家对象         |
        | Hiter   |\`object\` | 否   |      | 伤害来源对象     |
        | Damage  |\`number\` | 否   |      | 伤害值           |
        | MagicId |\`number\` | 否   |      | 技能ID           |
        | result  |\`number\` | 否   |      | 返回值<br>伤害值 |
        `
    },
    {
        "label": "attackdamage",
        "insertText": `
        function attackdamage(self, Target, Hiter, MagicId, Damage, Model)
            -- Your code here
        end
        `,
        "documentation": `
        ### 人物攻击前触发

        \`attackdamage\`

        > 参数6\`Model\`=3(切割) 新增于引擎64_23.12.07,触发需勾选m2的参数\`选项-物品参数-新增属性-启用切割\`

        | 参数    | 类型      | 空   | 默认                | 注释                                                 |
        | :------ | :-------- | :--- | :------------------ | :--------------------------------------------------- |
        | self    |\`object\`  | 否   |                     | 玩家对象                                             |
        | Target  |\`object\`  | 否   |                     | 受击对象                                             |
        | Hiter   |\`object\`  | 否   |                     | 攻击对象                                             |
        | MagicId |\`integer\` | 否   |                     | 技能ID                                               |
        | Damage  |\`integer\` | 否   |                     | 伤害                                                 |
        | Model   |\`integer\` | 否   | 引擎64_23.10.24新增 | 当前攻击模式<br>0=正常<br>1=暴击<br>2=格挡<br>3=切割 |
        | result  |\`integer\` | 否   |                     | 返回值，修改后的伤害                                 |
        `
    },
    {
        "label": "attackdamagebb",
        "insertText": `
        function attackdamagebb(self, Target, Hiter, MagicId, Damage)
            -- Your code here
        end
        `,
        "documentation": `
        ### 宝宝攻击前触发

        \`attackdamagebb\`

        | 参数    | 类型      | 空   | 默认 | 注释                 |
        | :------ | :-------- | :--- | :--- | :------------------- |
        | self    |\`object\`  | 否   |      | 玩家对象             |
        | Target  |\`object\`  | 否   |      | 受击对象             |
        | Hiter   |\`object\`  | 否   |      | 攻击对象             |
        | MagicId |\`integer\` | 否   |      | 技能ID               |
        | Damage  |\`integer\` | 否   |      | 伤害                 |
        | result  |\`integer\` | 否   |      | 返回值，修改后的伤害 |
        `
    },
    {
        "label": "heroattackdamage",
        "insertText": `
        function heroattackdamage(self, Target, Hiter, MagicId, Damage)
            -- Your code here
        end
        `,
        "documentation": `
        ### 英雄攻击前触发

        \`heroattackdamage\`

        | 参数    | 类型      | 空   | 默认 | 注释                 |
        | :------ | :-------- | :--- | :--- | :------------------- |
        | self    |\`object\`  | 否   |      | 玩家对象             |
        | Target  |\`object\`  | 否   |      | 受击对象             |
        | Hiter   |\`object\`  | 否   |      | 攻击对象             |
        | MagicId |\`integer\` | 否   |      | 技能ID               |
        | Damage  |\`integer\` | 否   |      | 伤害                 |
        | result  |\`integer\` | 否   |      | 返回值，修改后的伤害 |
        `
    },
    {
        "label": "heroattackdamagebb",
        "insertText": `
        function heroattackdamagebb(self, Target, Hiter, MagicId, Damage)
            -- Your code here
        end
        `,
        "documentation": `
        ### 英雄宝宝攻击前触发

        \`heroattackdamagebb\`

        | 参数    | 类型      | 空   | 默认 | 注释                 |
        | :------ | :-------- | :--- | :--- | :------------------- |
        | self    |\`object\`  | 否   |      | 玩家对象             |
        | Target  |\`object\`  | 否   |      | 受击对象             |
        | Hiter   |\`object\`  | 否   |      | 攻击对象             |
        | MagicId |\`integer\` | 否   |      | 技能ID               |
        | Damage  |\`integer\` | 否   |      | 伤害                 |
        | result  |\`integer\` | 否   |      | 返回值，修改后的伤害 |
        `
    },
    {
        "label": "attack",
        "insertText": `
        function attack(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击后触发

        \`attack\` 玩家物理攻击

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId      |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "magicattack",
        "insertText": `
        function magicattack(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击后触发

        \`magicattack\` 玩家魔法攻击

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "attackpet",
        "insertText": `
        function attackpet(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击后触发

        \`attackpet\` 宝宝物理攻击

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "magicattackpet",
        "insertText": `
        function magicattackpet(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击后触发

        \`magicattackpet\` 宝宝魔法攻击

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "heroattack",
        "insertText": `
        function heroattack(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击后触发

        \`heroattack\` 英雄物理攻击

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "heromagicattack",
        "insertText": `
        function heromagicattack(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击后触发

        \`heromagicattack\` 英雄魔法攻击

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "heroattackpet",
        "insertText": `
        function heroattackpet(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击后触发

        \`heroattackpet\` 英雄宝宝物理攻击

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "heromagicattackpet",
        "insertText": `
        function heromagicattackpet(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击后触发

        \`heromagicattackpet\` 英雄宝宝魔法攻击

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "struckdamage",
        "insertText": `
        function struckdamage(self, Hiter, Target, MagicId, Damage)
            -- Your code here
        end
        `,
        "documentation": `
        ### 受击前触发

        \`struckdamage\` 玩家受击

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        |Damage   |\`integer\`       |否   |    |   伤害 |
        |result   |\`integer\`       |否   |    |   返回值，修改后的伤害 |
        `
    },
    {
        "label": "struckdamagebb",
        "insertText": `
        function struckdamagebb(self, Hiter, Target, MagicId, Damage)
            -- Your code here
        end
        `,
        "documentation": `
        ### 受击前触发

        \`struckdamagebb\` 宝宝受击

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        |Damage   |\`integer\`       |否   |    |   伤害 |
        |result   |\`integer\`       |否   |    |   返回值，修改后的伤害 |
        `
    },
    {
        "label": "herostruckdamage",
        "insertText": `
        function herostruckdamage(self, Hiter, Target, MagicId, Damage)
            -- Your code here
        end
        `,
        "documentation": `
        ### 受击前触发

        \`herostruckdamage\` 英雄受击

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        |Damage   |\`integer\`       |否   |    |   伤害 |
        |result   |\`integer\`       |否   |    |   返回值，修改后的伤害 |
        `
    },
    {
        "label": "herostruckdamagebb",
        "insertText": `
        function herostruckdamagebb(self, Hiter, Target, MagicId, Damage)
            -- Your code here
        end
        `,
        "documentation": `
        ### 受击前触发

        \`herostruckdamagebb\` 英雄宝宝受击

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        |Damage   |\`integer\`       |否   |    |   伤害 |
        |result   |\`integer\`       |否   |    |   返回值，修改后的伤害 |
        `
    },
    {
        "label": "struck",
        "insertText": `
        function struck(self, Hiter, Target, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 受击后触发

        \`struck\` 玩家受击

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "struckpet",
        "insertText": `
        function struckpet(self, Hiter, Target, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 受击后触发

        \`struckpet\` 宝宝受击

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "herostruck",
        "insertText": `
        function herostruck(self, Hiter, Target, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 受击后触发

        \`herostruck\` 英雄受击

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "herostruckpet",
        "insertText": `
        function herostruckpet(self, Hiter, Target, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 受击后触发

        \`herostruckpet\` 英雄宝宝受击

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "attackmiss",
        "insertText": `
        function attackmiss(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击未命中触发

        \`attackmiss\` 玩家物理攻击未命中

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "magicattackmiss",
        "insertText": `
        function magicattackmiss(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击未命中触发

        \`magicattackmiss\` 玩家魔法攻击未命中

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "attackmisspet",
        "insertText": `
        function attackmisspet(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击未命中触发

        \`attackmisspet\` 宝宝物理攻击未命中

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "magicattackmisspet",
        "insertText": `
        function magicattackmisspet(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击未命中触发

        \`magicattackmisspet\` 宝宝魔法攻击未命中

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "heroattackmiss",
        "insertText": `
        function heroattackmiss(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击未命中触发

        \`heroattackmiss\` 英雄物理攻击未命中

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "heromagicattackmiss",
        "insertText": `
        function heromagicattackmiss(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击未命中触发

        \`heromagicattackmiss\` 英雄魔法攻击未命中

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "heroattackmisspet",
        "insertText": `
        function heroattackmisspet(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击未命中触发

        \`heroattackmisspet\` 英雄宝宝物理攻击未命中

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "heromagicattackmisspet",
        "insertText": `
        function heromagicattackmisspet(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击未命中触发

        \`heromagicattackmisspet\` 英雄宝宝魔法攻击未命中

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "attackblock",
        "insertText": `
        function attackblock(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击格挡触发

        \`attackblock\` 玩家物理攻击格挡

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "magicattackblock",
        "insertText": `
        function magicattackblock(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击格挡触发

        \`magicattackblock\` 玩家魔法攻击格挡

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "attackblockpet",
        "insertText": `
        function attackblockpet(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击格挡触发

        \`attackblockpet\` 宝宝物理攻击格挡

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "magicattackblockpet",
        "insertText": `
        function magicattackblockpet(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击格挡触发

        \`magicattackblockpet\` 宝宝魔法攻击格挡

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "heroattackblock",
        "insertText": `
        function heroattackblock(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击格挡触发

        \`heroattackblock\` 英雄物理攻击格挡

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "heromagicattackblock",
        "insertText": `
        function heromagicattackblock(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击格挡触发

        \`heromagicattackblock\` 英雄魔法攻击格挡

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "heroattackblockpet",
        "insertText": `
        function heroattackblockpet(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击格挡触发

        \`heroattackblockpet\` 英雄宝宝物理攻击格挡

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "heromagicattackblockpet",
        "insertText": `
        function heromagicattackblockpet(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击格挡触发

        \`heromagicattackblockpet\` 英雄宝宝魔法攻击格挡

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "attackparry",
        "insertText": `
        function attackparry(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击招架触发

        \`attackparry\` 玩家物理攻击招架

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "magicattackparry",
        "insertText": `
        function magicattackparry(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击招架触发

        \`magicattackparry\` 玩家魔法攻击招架

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "attackparrypet",
        "insertText": `
        function attackparrypet(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击招架触发

        \`attackparrypet\` 宝宝物理攻击招架

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "magicattackparrypet",
        "insertText": `
        function magicattackparrypet(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击招架触发

        \`magicattackparrypet\` 宝宝魔法攻击招架

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "heroattackparry",
        "insertText": `
        function heroattackparry(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击招架触发

        \`heroattackparry\` 英雄物理攻击招架

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "heromagicattackparry",
        "insertText": `
        function heromagicattackparry(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击招架触发

        \`heromagicattackparry\` 英雄魔法攻击招架

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "heroattackparrypet",
        "insertText": `
        function heroattackparrypet(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击招架触发

        \`heroattackparrypet\` 英雄宝宝物理攻击招架

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "heromagicattackparrypet",
        "insertText": `
        function heromagicattackparrypet(self, Target, Hiter, MagicId)
            -- Your code here
        end
        `,
        "documentation": `
        ### 攻击招架触发

        \`heromagicattackparrypet\` 英雄宝宝魔法攻击招架

        |参数|类型|空|默认|注释|
        |:----    |:-------    |:--- |----|------      |
        |self     |\`object\`        |否   |    |   玩家对象    |
        |Target   |\`object\`        |否   |    |   受击对象    |
        |Hiter    |\`object\`        |否   |    |   攻击对象    |
        |MagicId  |\`integer\`       |否   |    |   技能ID |
        `
    },
    {
        "label": "magselffunc",
        "insertText": dedent`
        magselffunc(\${1:X})
        `,
        "documentation": dedent`## magselffunc(X)

        > X=触发技能ID

        | 参数  | 类型     | 空   | 默认 | 注释     |
        | :---- | :------- | :--- | :--- | :------- |
        | self  | \`object\` | 否   |      | 玩家对象 |
        `
    },
    {
        "label": "magtagfunc",
        "insertText": dedent`
        magtagfunc(\${1:X})
        `,
        "documentation": dedent`## magtagfunc(X)

        > X=触发技能ID

        | 参数        | 类型     | 空   | 默认                | 注释           |
        | :---------- | :------- | :--- | :------------------ | :------------- |
        | self        | \`object\` | 否   |                     | 玩家对象       |
        | roleObject  | \`object\` | 否   | 引擎64_23.06.28新增 | 受击玩家对象   |
        `
    },
    {
        "label": "magmonfunc",
        "insertText": dedent`
        magmonfunc(\${1:X})
        `,
        "documentation": dedent`## magmonfunc(X)

        > X=触发技能ID

        | 参数       | 类型     | 空   | 默认                | 注释           |
        | :--------- | :------- | :--- | :------------------ | :------------- |
        | self       | \`object\` | 否   |                     | 玩家对象       |
        | monObject  | \`object\` | 否   | 引擎64_23.06.28新增 | 受击怪物对象   |
        `
    },
    {
        "label": "beginmagic",
        "insertText": dedent`
        beginmagic(\${1:self}, \${2:maigicID}, \${3:maigicName}, \${4:targetObject}, \${5:x}, \${6:y}, \${7:result})
        `,
        "documentation": dedent`## beginmagic

        > magselffunc(X)触发优先级在beginmagic前,阻止释放并不会影响触发magselffunc(X)

        | 参数         | 类型      | 空   | 默认 | 注释                                |
        | :----------- | :-------- | :--- | :--- | :---------------------------------- |
        | self         | \`object\`  | 否   |      | 玩家对象                            |
        | maigicID     | \`integer\` | 否   |      | 技能id                              |
        | maigicName   | \`string\`  | 否   |      | 技能名字                            |
        | targetObject | \`object\`  | 否   |      | 受击对象                            |
        | x            | \`integer\` | 否   |      | 受击对象X坐标                       |
        | y            | \`integer\` | 否   |      | 受击对象Y坐标                       |
        | result       | \`bool\`    | 否   |      | 返回值<br>true/nil=允许施法<br>false=阻止施法 |
        `
    },
    {
        "label": "herobeginmagic",
        "insertText": dedent`
        herobeginmagic(\${1:self}, \${2:maigicID}, \${3:maigicName}, \${4:targetObject}, \${5:x}, \${6:y}, \${7:result})
        `,
        "documentation": dedent`## herobeginmagic

        > magselffunc(X)触发优先级在beginmagic前,阻止释放并不会影响触发magselffunc(X)

        | 参数         | 类型      | 空   | 默认 | 注释                                |
        | :----------- | :-------- | :--- | :--- | :---------------------------------- |
        | self         | \`object\`  | 否   |      | 玩家对象                            |
        | maigicID     | \`integer\` | 否   |      | 技能id                              |
        | maigicName   | \`string\`  | 否   |      | 技能名字                            |
        | targetObject | \`object\`  | 否   |      | 受击对象                            |
        | x            | \`integer\` | 否   |      | 受击对象X坐标                       |
        | y            | \`integer\` | 否   |      | 受击对象Y坐标                       |
        | result       | \`bool\`    | 否   |      | 返回值<br>true/nil=允许施法<br>false=阻止施法 |
        `
    },
    {
        "label": "canpush",
        "insertText": dedent`
        canpush(\${1:self}, \${2:Target}, \${3:Hiter}, \${4:MagicId}, \${5:result})
        `,
        "documentation": dedent`## canpush

        | 参数    | 类型      | 空   | 默认 | 注释                                                                 |
        | :------ | :-------- | :--- | :--- | :------------------------------------------------------------------- |
        | self    | \`object\`  | 否   |      | 玩家对象                                                             |
        | Target  | \`object\`  | 否   |      | 受击对象                                                             |
        | Hiter   | \`object\`  | 否   |      | 攻击对象                                                             |
        | MagicId | \`integer\` | 否   |      | 技能ID                                                               |
        | result  | \`bool\`    | 否   |      | 返回值<br>0=不执行推动<br>1=执行推动<br>2=根据M2上的推动条件判断是否执行 |
        `
    },
    {
        "label": "herocanpush",
        "insertText": dedent`
        herocanpush(\${1:self}, \${2:Target}, \${3:Hiter}, \${4:MagicId}, \${5:result})
        `,
        "documentation": dedent`## herocanpush

        | 参数    | 类型      | 空   | 默认 | 注释                                                                 |
        | :------ | :-------- | :--- | :--- | :------------------------------------------------------------------- |
        | self    | \`object\`  | 否   |      | 玩家对象                                                             |
        | Target  | \`object\`  | 否   |      | 受击对象                                                             |
        | Hiter   | \`object\`  | 否   |      | 攻击对象                                                             |
        | MagicId | \`integer\` | 否   |      | 技能ID                                                               |
        | result  | \`bool\`    | 否   |      | 返回值<br>0=不执行推动<br>1=执行推动<br>2=根据M2上的推动条件判断是否执行 |
        `
    },
    {
        "label": "petcanpush",
        "insertText": dedent`
        petcanpush(\${1:self}, \${2:Target}, \${3:Hiter}, \${4:MagicId}, \${5:result})
        `,
        "documentation": dedent`## petcanpush

        | 参数    | 类型      | 空   | 默认 | 注释                                                                 |
        | :------ | :-------- | :--- | :--- | :------------------------------------------------------------------- |
        | self    | \`object\`  | 否   |      | 玩家对象                                                             |
        | Target  | \`object\`  | 否   |      | 受击对象                                                             |
        | Hiter   | \`object\`  | 否   |      | 攻击对象                                                             |
        | MagicId | \`integer\` | 否   |      | 技能ID                                                               |
        | result  | \`bool\`    | 否   |      | 返回值<br>0=不执行推动<br>1=执行推动<br>2=根据M2上的推动条件判断是否执行 |
        `
    },
    {
        "label": "bbcanpush",
        "insertText": dedent`
        bbcanpush(\${1:self}, \${2:Target}, \${3:Hiter}, \${4:MagicId}, \${5:result})
        `,
        "documentation": dedent`## bbcanpush
    
        | 参数    | 类型      | 空   | 默认 | 注释                                                                 |
        | :------ | :-------- | :--- | :--- | :------------------------------------------------------------------- |
        | self    | \`object\`  | 否   |      | 玩家对象                                                             |
        | Target  | \`object\`  | 否   |      | 受击对象                                                             |
        | Hiter   | \`object\`  | 否   |      | 攻击对象                                                             |
        | MagicId | \`integer\` | 否   |      | 技能ID                                                               |
        | result  | \`bool\`    | 否   |      | 返回值<br>0=不执行推动<br>1=执行推动<br>2=根据M2上的推动条件判断是否执行 |
        `
    },
    {
        "label": "herobbcanpush",
        "insertText": dedent`
        herobbcanpush(\${1:self}, \${2:Target}, \${3:Hiter}, \${4:MagicId}, \${5:result})
        `,
        "documentation": dedent`## herobbcanpush

        | 参数    | 类型      | 空   | 默认 | 注释                                                                 |
        | :------ | :-------- | :--- | :--- | :------------------------------------------------------------------- |
        | self    | \`object\`  | 否   |      | 玩家对象                                                             |
        | Target  | \`object\`  | 否   |      | 受击对象                                                             |
        | Hiter   | \`object\`  | 否   |      | 攻击对象                                                             |
        | MagicId | \`integer\` | 否   |      | 技能ID                                                               |
        | result  | \`bool\`    | 否   |      | 返回值<br>0=不执行推动<br>1=执行推动<br>2=根据M2上的推动条件判断是否执行 |
        `
    },
    {
        "label": "custommagicdamage",
        "insertText": dedent`
        custommagicdamage(\${1:X})
        `,
        "documentation": dedent`## custommagicdamage(X)

        | 参数   | 类型     | 空   | 默认 | 注释                                                                 |
        | :----- | :------- | :--- | :--- | :------------------------------------------------------------------- |
        | Hiter  | \`object\` | 否   |      | 施法对象                                                             |
        | Target | \`object\` | 否   |      | 受击对象                                                             |
        | result | \`bool\`   | 否   |      | 返回值<br>true=正常施法<br>false=阻止施法(将不走后续伤害触发)<br>可用于群攻类技能,阻止部分受击对象的伤害流程 |
        `
    }
];




export function getCompletionItems(): vscode.CompletionItem[] {


    const completionItems: vscode.CompletionItem[] = [];
    actionItems.forEach((item: any) => {
        completionItems.push(createFunctionCompletionItem(item.label, item.insertText, item.documentation));
    });
    return completionItems;
}

function createFunctionCompletionItem(label: string, insertText: string, documentation?: string): vscode.CompletionItem {
    const item = new vscode.CompletionItem(label, vscode.CompletionItemKind.Function);
    item.insertText = new vscode.SnippetString(insertText);
    if (documentation) {
        item.documentation = new vscode.MarkdownString(documentation);
    }
    return item;
}
